home *** CD-ROM | disk | FTP | other *** search
/ SGI Developer Toolbox 6.1 / SGI Developer Toolbox 6.1 - Disc 4.iso / src / haeberli / objtools / subdiv.c < prev    next >
C/C++ Source or Header  |  1994-08-01  |  4KB  |  199 lines
  1. /*
  2.  * Copyright 1991, 1992, 1993, 1994, Silicon Graphics, Inc.
  3.  * All Rights Reserved.
  4.  *
  5.  * This is UNPUBLISHED PROPRIETARY SOURCE CODE of Silicon Graphics, Inc.;
  6.  * the contents of this file may not be disclosed to third parties, copied or
  7.  * duplicated in any form, in whole or in part, without the prior written
  8.  * permission of Silicon Graphics, Inc.
  9.  *
  10.  * RESTRICTED RIGHTS LEGEND:
  11.  * Use, duplication or disclosure by the Government is subject to restrictions
  12.  * as set forth in subdivision (c)(1)(ii) of the Rights in Technical Data
  13.  * and Computer Software clause at DFARS 252.227-7013, and/or in similar or
  14.  * successor clauses in the FAR, DOD or NASA FAR Supplement. Unpublished -
  15.  * rights reserved under the Copyright Laws of the United States.
  16.  */
  17. /* 
  18.  *    subdiv -
  19.  *        Sub-divide triangles to some tolerance.
  20.  *
  21.  *            Paul Haeberli - 1990
  22.  */
  23. #include "stdio.h"
  24. #include "math.h"
  25. #include "vect.h"
  26. #include "sgiobj.h"
  27.  
  28. sgiobj *subdiv();
  29.  
  30. main(argc,argv)
  31. int argc;
  32. char **argv;
  33. {
  34.     sgiobj *obj;
  35.     float tol;
  36.  
  37.     if(argc<4) {
  38.     fprintf(stderr,"usage: subdiv in.sgo out.sgo tol\n");
  39.     exit(1);
  40.     }
  41.     obj = readsgiobj(argv[1]);
  42.     tol = atof(argv[3]);
  43.     obj = subdiv(obj,tol);
  44.     writesgiobj(argv[2],obj);
  45.     exit(0);
  46. }
  47.  
  48. /*
  49.  *    subdiv stuff follows
  50.  *
  51.  */
  52. typedef struct tri {
  53.     struct tri *next;
  54.     float data[3*PNTLONGS];
  55. } tri;
  56.  
  57. static tri *tlist;
  58. int ntri;
  59.  
  60. sgiobj *subdiv(obj,tol)
  61. sgiobj *obj;
  62. float tol;
  63. {
  64.     int npolys;
  65.     float *fptr;
  66.     sgiobj *sobj;
  67.     tri *tptr;
  68.  
  69.     if(obj->objtype != OBJ_TRILIST) {
  70.     fprintf(stderr,"subdiv: objject must be triangle list\n");
  71.     exit(1);
  72.     }
  73.     fptr = (float *)obj->data;
  74.     npolys = (obj->nlongs/PNTLONGS)/3;
  75.     printf("npolys in %d\n",npolys);
  76.     while(npolys--) {
  77.     subdivtri(fptr+(0*PNTLONGS),fptr+(1*PNTLONGS),fptr+(2*PNTLONGS),tol);
  78.     fptr += 3*PNTLONGS;
  79.     }
  80.     sobj = newtriobj(ntri);
  81.     fptr = (float *)sobj->data;
  82.     tptr = tlist;
  83.     printf("npolys out %d\n",ntri);
  84.     while(tptr) {
  85.     bcopy(tptr->data,fptr,3*PNTLONGS*sizeof(float));
  86.     fptr += 3*PNTLONGS;
  87.     tptr = tptr->next;
  88.     }
  89.     return sobj;
  90. }
  91.  
  92. #define NONE    0x0
  93. #define D0    0x1
  94. #define D1    0x2
  95. #define D2    0x4
  96.  
  97. subdivtri(v0,v1,v2,tol)
  98. float *v0, *v1, *v2;
  99. float tol;
  100. {
  101.     float d0, d1, d2;
  102.     float i0[PNTLONGS];
  103.     float i1[PNTLONGS];
  104.     float i2[PNTLONGS];
  105.     vect d;
  106.     int code;
  107.  
  108.     vsub(v0+OFFSET_POINT,v1+OFFSET_POINT,&d);
  109.     d0 = vlength(&d);
  110.     vsub(v1+OFFSET_POINT,v2+OFFSET_POINT,&d);
  111.     d1 = vlength(&d);
  112.     vsub(v2+OFFSET_POINT,v0+OFFSET_POINT,&d);
  113.     d2 = vlength(&d);
  114.     code = NONE;
  115.     if(d0>tol)
  116.     code |= D0;
  117.     if(d1>tol)
  118.     code |= D1;
  119.     if(d2>tol)
  120.     code |= D2;
  121.     switch(code) {
  122.     case NONE:
  123.         outtri(v0,v1,v2);
  124.         break;
  125.     case D0:
  126.         plerp(v0,v1,i0);
  127.         subdivtri(v0,i0,v2,tol);
  128.         subdivtri(v2,i0,v1,tol);
  129.         break;
  130.     case D1:
  131.         plerp(v1,v2,i0);
  132.         subdivtri(v1,i0,v0,tol);
  133.         subdivtri(v0,i0,v2,tol);
  134.         break;
  135.     case D2:
  136.         plerp(v2,v0,i0);
  137.         subdivtri(v2,i0,v1,tol);
  138.         subdivtri(v1,i0,v0,tol);
  139.         break;
  140.     case D0|D1:
  141.         plerp(v0,v1,i0);
  142.         plerp(v1,v2,i1);
  143.         subdivtri(v0,i0,v2,tol);
  144.         subdivtri(v2,i0,i1,tol);
  145.         subdivtri(v1,i1,i0,tol);
  146.         break;
  147.     case D1|D2:
  148.         plerp(v1,v2,i0);
  149.         plerp(v2,v0,i1);
  150.         subdivtri(v1,i0,v0,tol);
  151.         subdivtri(v0,i0,i1,tol);
  152.         subdivtri(v2,i1,i0,tol);
  153.         break;
  154.     case D2|D0:
  155.         plerp(v2,v0,i0);
  156.         plerp(v0,v1,i1);
  157.         subdivtri(v2,i0,v1,tol);
  158.         subdivtri(v1,i0,i1,tol);
  159.         subdivtri(v0,i1,i0,tol);
  160.         break;
  161.     case D2|D1|D0:
  162.         plerp(v0,v1,i0);
  163.         plerp(v1,v2,i1);
  164.         plerp(v2,v0,i2);
  165.         subdivtri(v0,i0,i2,tol);
  166.         subdivtri(v1,i1,i0,tol);
  167.         subdivtri(v2,i2,i1,tol);
  168.         subdivtri(i0,i1,i2,tol);
  169.         break;
  170.     }
  171. }
  172.  
  173. plerp(v0,v1,l)
  174. float *v0, *v1, *l;
  175. {
  176.     int i;
  177.  
  178.     for(i=0; i<PNTLONGS; i++) 
  179.     *l++ = (*v0++ + *v1++)/2.0;
  180. }
  181.  
  182. outtri(v0,v1,v2)
  183. float *v0, *v1, *v2;
  184. {
  185.     tri *t;
  186.     float *fptr;
  187.  
  188.     t = (tri *)malloc(sizeof(tri));
  189.     fptr = t->data;
  190.     bcopy(v0,fptr,PNTLONGS*sizeof(float));
  191.     fptr += PNTLONGS;
  192.     bcopy(v1,fptr,PNTLONGS*sizeof(float));
  193.     fptr += PNTLONGS;
  194.     bcopy(v2,fptr,PNTLONGS*sizeof(float));
  195.     t->next = tlist;
  196.     tlist = t;
  197.     ntri++;
  198. }
  199.